﻿using System;
using System.Windows;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Xml;
using System.IO;
using System.Reflection;
using Comm.PublicClass;
using System.Runtime.Serialization;
using Wasion.HHU.Data.Repositories;
using Wasion.HHU.Data.Models;

namespace WsProtocol.IEC62056MDL
{  
    public enum TSchType
    { 
        schRAW = 0,  //协议一致性专用方案
        schPtl = 1   //推荐值方案
    }

    [DataContract]
    public class ProSchema : IDisposable
    {
        private static SchemaDbRepository schemaDbRepository = new SchemaDbRepository();
        private static string ptltable = "T_Schema";
        public int schtype;

        public static List<ProSchema> Schlst = new List<ProSchema>(); //方案列表
        public Dictionary<string, ProSchemaItem> SchemaItemlst = new Dictionary<string, ProSchemaItem>(); //方案元素列表 
        public string ID { get; set; }
        public string SchName { get; set; }
        public string ModifiedBy { get; set; }
        public string DateModified { get; set; }
        public TSchType SchType  //方案类别
        {
            get
            {
                try
                {
                    return (TSchType)schtype;
                }
                catch
                {
                    return TSchType.schRAW;
                }
            }
            set
            {
                schtype = (int)value;
            }
        }
        public string SchemaDesc { get; set; }

        public ProSchema()
        {
            SchemaItemlst = new Dictionary<string, ProSchemaItem>();
            SchType = TSchType.schRAW;
        }

        public ProSchema(string aName)
        {
            SchemaItemlst = new Dictionary<string, ProSchemaItem>();
            SchName = aName;
        }

        public void Dispose()
        {
            Schlst.Remove(this);
            GC.SuppressFinalize(this);
        }


        public object Clone()
        {
            return this.MemberwiseClone();
        }

        //复制自身
        public ProSchema Copy()
        {
            //新建一个
            ProSchema newsch = new ProSchema();

            //复制属性
            PropertyInfo[] fromFields = typeof(ProSchema).GetProperties();
            PubFunction.SetProperties(fromFields, this, newsch);

            newsch.ID = string.Empty;

            return newsch;
        }

        //private static List<ProSchema> TableToList(DataTable dt)
        //{
        //    List<ProSchema> list = new List<ProSchema>();
        //    ProSchema m = null;
        //    if (dt == null) return list;
        //    foreach (DataRow dr in dt.Rows)
        //    {
        //        m = GetModelByDataRow(dr);

        //        list.Add(m);
        //    }
        //    return list;
        //}

        /// <summary>
        /// 数据行转对象
        /// </summary>
        /// <param name="dr"></param>
        /// <returns></returns>
        public static ProSchema GetModelByDb(Schema dr)
        {
            ProSchema m = new ProSchema();

            m.ID = dr.ID;
            m.SchName = dr.SchName;
            m.ModifiedBy = dr.ModifiedBy;
            m.DateModified = dr.DateModified;
            //try
            //{
            //    m.schtype = Convert.ToInt16(dr["SchType"].ToString());
            //}
            //catch
            //{ }
            m.SchemaDesc = dr.SchemaDesc;
            return m;
        }

        //获取数据库中的所有方案
        private static List<ProSchema> GetAllSch()
        {
            //PtlConsts.easyDb.Clear();
            //PtlConsts.easyDb.TableName = ptltable;
            //PtlConsts.easyDb.SetOrder("SchName");
            //Schlst = ProSchema.TableToList(PtlConsts.easyDb.Select());
            //return Schlst;

            var list = schemaDbRepository.GetAllList().Result;

            foreach (var item in list)
            {
                var m = GetModelByDb(item);

                Schlst.Add(m);
            }
            return Schlst;
        }


        //获取数据库中的所有方案
        public static List<ProSchema> GetAllSch(TSchType schtype)
        {
            GetAllSch();
            List<ProSchema> alst = new List<ProSchema>();
            for (int i = 0; i < Schlst.Count; i++)
            {
                if (Schlst[i].SchType == schtype)
                    alst.Add(Schlst[i]);
            }
            return alst;
        }


        /// <summary>
        /// 清空原数据，准备重新加载
        /// </summary>
        public static void Clear()
        {
            Schlst.Clear();
        }

        /// <summary>
        /// 根据方案名获取ID
        /// </summary>
        /// <param name="schname"></param>
        /// <returns></returns>
        public static string GetIdByName(string schname)
        {
            string schid = string.Empty;
            if (Schlst.Count == 0)
                GetAllSch();
            for (int i = 0; i < Schlst.Count; i++)
            {
                if (Schlst[i].SchName == schname)
                {
                    schid = Schlst[i].ID;
                    break;
                }
            }
            return schid;
        }


        /// <summary>
        /// 删除某一类的方案
        /// </summary>
        /// <param name="schname"></param>
        /// <returns></returns>
        //public static int DeleteByType(TSchType schtype, ref string errinfo)
        //{
        //    int rs = 0;
        //    if (Schlst.Count == 0)
        //        GetAllSch();
        //    for (int i = Schlst.Count - 1; i >= 0; i--)
        //    {
        //        if (Schlst[i].SchType == schtype)
        //        {
        //            rs = Schlst[i].DeleteSchByID(ref errinfo);
        //            if (rs < 0)
        //                break;
        //        }
        //    }
        //    return rs;
        //}


        /// <summary>
        /// 根据方案名获取方案对象
        /// </summary>
        /// <param name="schname"></param>
        /// <returns></returns>
        public static ProSchema GetSchemaByName(string schname, TSchType schtype)
        {
            ProSchema aschema = null;
            if (Schlst.Count == 0)
                GetAllSch();
            for (int i = 0; i < Schlst.Count; i++)
            {
                if (Schlst[i].SchName == schname && Schlst[i].SchType == schtype)
                {
                    aschema = Schlst[i];
                    break;
                }
            }
            return aschema;
        }

        /// <summary>
        /// 获取新ID
        /// </summary>
        /// <returns></returns>
        public static string GetNewId()
        {
            return Guid.NewGuid().ToString();
        }

        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="insertFlag">true时是插入增加,false更新</param>
        /// <returns></returns>
        //public int SaveSch(bool insertFlag, ref string errinfo)
        //{
        //    PtlConsts.easyDb.Clear();
        //    PtlConsts.easyDb.TableName = ptltable;
        //    PtlConsts.easyDb.SetFieldValue("SchName", SchName, EasyDataType.String);
        //    PtlConsts.easyDb.SetFieldValue("ModifiedBy", ModifiedBy, EasyDataType.String);
        //    DateModified = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
        //    PtlConsts.easyDb.SetFieldValue("DateModified", DateModified, EasyDataType.String);
        //    //PtlConsts.easyDb.SetFieldValue("SchType", ((int)SchType).ToString(), EasyDataType.Number);
        //    PtlConsts.easyDb.SetFieldValue("SchemaDesc", SchemaDesc, EasyDataType.String);
        //    if (insertFlag)
        //    {
        //        if (string.IsNullOrEmpty(ID))
        //            ID = GetNewId();
        //        PtlConsts.easyDb.SetFieldValue("ID", ID, EasyDataType.String);
        //        int rs = PtlConsts.easyDb.Insert(ref errinfo);
        //        if (rs > 0)
        //            Schlst.Add(this);
        //        return rs;
        //    }
        //    else
        //    {
        //        PtlConsts.easyDb.SetWhereParameter(true, "ID", "=", ID, EasyDataType.String);
        //        return PtlConsts.easyDb.Update(ref errinfo);
        //    }
        //}

        //public int DeleteSchByID(ref string errinfo)
        //{
        //    if (string.IsNullOrEmpty(ID)) return 1;
        //    try
        //    {
        //        //先删除方案项  shaunwang 2017-2-10
        //        int rs = ClearSchemaLst(ref errinfo);
        //        if (rs < 0)
        //            return rs;

        //        PtlConsts.easyDb.Clear();
        //        PtlConsts.easyDb.TableName = ptltable;
        //        PtlConsts.easyDb.SetWhereParameter(true, "ID", "=", ID, EasyDataType.String);
        //        rs = PtlConsts.easyDb.Delete(ref errinfo);
        //        if (rs > 0)
        //            this.Dispose();
        //        return rs;
        //    }
        //    catch
        //    {
        //        return -1;
        //    }
        //}



        /// <summary>
        /// 获取方案项
        /// </summary>
        //public void GetSchemaItemLst()
        //{
        //    this.SchemaItemlst.Clear();
        //    List<ProSchemaItem> schItemlst = ProSchemaItem.GetSchItemBySch(ID);

        //    for (int i = 0; i < schItemlst.Count; i++)
        //    {
        //        if (!this.SchemaItemlst.ContainsKey(schItemlst[i].ObAttrMthID))
        //            this.SchemaItemlst.Add(schItemlst[i].ObAttrMthID, schItemlst[i]);
        //    }

        //}

        /// <summary>
        /// 清空方案项
        /// </summary>
        //public int ClearSchemaLst(ref string errinfo)
        //{
        //    //先删除原来的方案项
        //    int rs = ProSchemaItem.DeleteItemBySchID(ID, ref errinfo);
        //    if (rs < 0)
        //        return rs;

        //    this.SchemaItemlst.Clear();
        //    return rs;

        //}

        /// <summary>
        /// 根据ID判别方案是否已存在
        /// </summary>
        /// <returns></returns>
        //private bool IsExistSchByID()
        //{
        //    try
        //    {
        //        PtlConsts.easyDb.Clear();
        //        PtlConsts.easyDb.TableName = ptltable;
        //        PtlConsts.easyDb.SetWhereParameter(true, "ID", "=", ID, EasyDataType.String);
        //        return PtlConsts.easyDb.Select().Rows.Count > 0 ? true : false;
        //    }
        //    catch
        //    {
        //        return false;
        //    }
        //}

        /// <summary>
        /// 导出方案
        /// </summary>
        /// <param name="sfilename"></param>
        /// <param name="schtype"></param> 
        /// <param name="errinfo"></param>
        /// <returns></returns>
        //public int ExportSch(string sfilename, TSchType schtype, ref string errinfo)
        //{
        //    int rs = 0;
        //    switch (schtype)
        //    { 
        //        case TSchType.schRAW:
        //            rs = ExportSchRAW(sfilename, ref errinfo);
        //            break;
        //        case TSchType.schPtl:
        //            rs = ExportSchPtl(sfilename, ref errinfo);
        //            break;
        //    }
        //    return rs;
        //}


        ///// <summary>
        ///// 导入方案
        ///// </summary>
        ///// <param name="sfilename"></param>
        ///// <param name="schtype"></param> 
        ///// <param name="errinfo"></param>
        ///// <returns></returns>
        //public static ProSchema ImportSch(DataSet dsSchema, ref string errinfo)
        //{
        //    ProSchema rs = ImportSchRAW(dsSchema, ref errinfo);
        //}


        ///// <summary>
        ///// 导入默认参数模板方案
        ///// </summary>
        ///// <param name="sfilename"></param>
        ///// <param name="schtype"></param> 
        ///// <param name="errinfo"></param>
        ///// <returns></returns>
        //public static int ImportSch(DataSet dsSchema, ref string errinfo)
        //{
        //    int rs = ImportSchPtl(dsSchema, ref errinfo);
        //}

        ///// <summary>
        ///// 删除某一类方案
        ///// </summary>
        ///// <param name="atype"></param>
        ///// <param name="errinfo"></param>
        ///// <returns></returns>
        //public int DeleteSchByType(SchemaType atype, ref string errinfo)
        //{
        //    try
        //    {
        //        //先删除方案项  shaunwang 2017-2-10
        //        int rs = ClearSchemaLst(ref errinfo);
        //        if (rs < 0)
        //            return rs;

        //        PtlConsts.easyDb.Clear();
        //        PtlConsts.easyDb.TableName = ptltable;
        //        PtlConsts.easyDb.SetWhereParameter(true, "ID", "=", ID, EasyDataType.String);
        //        rs = PtlConsts.easyDb.Delete(ref errinfo);
        //        if (rs > 0)
        //            this.Dispose();
        //        return rs;
        //    }
        //    catch
        //    {
        //        return -1;
        //    }
        //}
        #region 协议一致性用方案
        /// <summary>
        /// 导出方案
        /// </summary>
        /// <param name="sfilename"></param>
        /// <param name="errinfo"></param>
        /// <returns></returns>
        //public int ExportSchRAW(string sfilename, ref string errinfo)
        //{
        //    int rs = 0;
        //    try
        //    {
        //        Application.DoEvents();
        //        #region 添加方案名信息
        //        PtlConsts.easyDb.Clear();
        //        PtlConsts.easyDb.TableName = ptltable;
        //        PtlConsts.easyDb.SetWhereParameter(true, "ID", "=", ID, EasyDataType.String);
        //        DataTable dtSchema = PtlConsts.easyDb.Select();
        //        if (dtSchema.Rows.Count <= 0)
        //        {
        //            errinfo = clsLan.GetLan("未在数据库中找到方案") + "[" + sfilename + "]";
        //            return -1;
        //        }
        //        DataSet dsSchema = new DataSet();
        //        dtSchema.TableName = ptltable;
        //        dsSchema.Tables.Add(dtSchema.Copy());
        //        #endregion

        //        #region 添加方案项
        //        DataTable dtSchItem = ProSchemaItem.GetItemDataTableBySch(ID);
        //        dsSchema.Tables.Add(dtSchItem.Copy());
        //        #endregion

        //        #region 添加方案项参数
        //        DataTable dtSchItemPar = ProSchemaItem.GetParDataTablePar(ID);
        //        dsSchema.Tables.Add(dtSchItemPar.Copy());
        //        #endregion


        //        #region 添加协议库信息
        //        DataTable dtLocalPtl = TLocalPtl.GetLocalPtlDataTable();
        //        dsSchema.Tables.Add(dtLocalPtl.Copy());
        //        #endregion


        //        if (!RWOutFiles.DataSetToXMl(dsSchema, sfilename, ref errinfo))
        //            rs = -1;
        //    }
        //    catch (Exception ex)
        //    {
        //        rs = -1;
        //        errinfo = ex.Message;
        //    }

        //    return rs;
        //}

        

        /// <summary>
        /// 导入方案
        /// </summary>
        /// <param name="sfilename"></param>
        /// <param name="errinfo"></param>
        /// <returns></returns>
        //public static ProSchema ImportSchRAW(DataSet dsSchema, ref string errinfo)
        //{
        //    return ImportSchRAW(dsSchema,true,false, ref errinfo);
        //}

        /// <summary>
        /// 导入方案重写，加入了是否提示，是否替换 add by xd 2018-12-11
        /// </summary>
        /// <param name="dsSchema"></param>
        /// <param name="errinfo"></param>
        /// <param name="blnmsg">是否提示</param>
        /// <param name="blnreplace">是否替换</param>
        /// <returns></returns>
        //public static ProSchema ImportSchRAW(DataSet dsSchema, bool blnmsg, bool blnreplace, ref string errinfo)
        //{
        //    ProSchema aschema = null;
            
        //    //检查协议库信息
        //    try
        //    {
        //        if (dsSchema.Tables.Count == 4)
        //        {
        //            DataTable dtimport = dsSchema.Tables[3];

        //            if (dtimport.Rows.Count > 0)
        //            {
        //                TLocalPtl ptlimport = TLocalPtl.GetModelByDataRow(dtimport.Rows[0]);  //导入方案的协议库信息

        //                if (TLocalPtl.LocalPtlInfo.ID != ptlimport.ID)  //导入协议库和本地协议库ID不一致
        //                {
        //                    DialogResult drs = MessageBox.Show(clsLan.GetLan("待导入方案的协议库版本和目前所用协议库版本不一致，导入可能会有问题，是否继续？"), clsLan.GetLan("询问"), MessageBoxButtons.YesNo, MessageBoxIcon.Question);
        //                    if (drs == DialogResult.No)  //不导入
        //                        return aschema;
        //                }
        //            }
        //        }
        //    }
        //    catch
        //    { 
            
        //    }
            
            
        //    try
        //    {
        //        PtlConsts.easyDb.BeginTrans();
        //        aschema = GetModelByDataRow(dsSchema.Tables[ptltable].Rows[0]);
        //        aschema.ID = string.Empty;
        //        ProSchema findchema = GetSchemaByName(aschema.SchName, aschema.SchType);
        //        if (findchema != null)  //已经存在
        //        {
        //            if (blnmsg)
        //            {
        //                DialogResult drs = MessageBox.Show("[" + aschema.SchName + "]" + clsLan.GetLan("已经存在，是否覆盖？"), clsLan.GetLan("询问"), MessageBoxButtons.YesNo, MessageBoxIcon.Question);
        //                if (drs == DialogResult.No)  //不覆盖
        //                {
        //                    aschema.SchName += "["
        //                                     + DateTime.Now.ToString("yyyyMMddHHmm")
        //                                     + "]";
        //                }
        //                else  //覆盖
        //                    aschema.ID = findchema.ID;
        //            }
        //            else
        //            {
        //                if (!blnreplace)
        //                {
        //                    aschema.SchName += "["
        //                                     + DateTime.Now.ToString("yyyyMMddHHmm")
        //                                     + "]";
        //                }
        //                else
        //                {
        //                    aschema.ID = findchema.ID;
        //                }
        //            }
        //        }

        //        //保存方案
        //        int rs = aschema.SaveSch(string.IsNullOrEmpty(aschema.ID), ref errinfo);
        //        if (rs < 0)
        //        {
        //            PtlConsts.easyDb.RollbackTrans();
        //            return null;
        //        }

        //        //保存方案项
        //        //先删除原来的方案项
        //        rs = aschema.ClearSchemaLst(ref errinfo);
        //        if (rs < 0)
        //        {
        //            PtlConsts.easyDb.RollbackTrans();
        //            return null;
        //        }


        //        //方案项导入
        //        DataTable dtSchItem = dsSchema.Tables[1];
        //        foreach (DataRow dr in dtSchItem.Rows)
        //        {
        //            ProSchemaItem schitem = ProSchemaItem.GetModelByDataRow(dr);
        //            schitem.SchID = aschema.ID;
        //            rs = schitem.SaveSchItem(true, ref errinfo);
        //            if (rs < 0)
        //            {
        //                PtlConsts.easyDb.RollbackTrans();
        //                return null;
        //            }

        //        }

        //        //方案项参数导入
        //        DataTable dtSchItemPar = dsSchema.Tables[2];
        //        foreach (DataRow dr in dtSchItemPar.Rows)
        //        {
        //            ProObAttr itempar = ProObAttr.GetModelByDataRow(dr);
        //            rs = ProSchemaItem.SaveSchemaAttrPar(aschema.ID,itempar, false,itempar.PID, true, ref errinfo);//导入方案时不能重新生成参数ID，否则ID、PID会对应不上
        //            if (rs < 0)
        //            {
        //                PtlConsts.easyDb.RollbackTrans();
        //                return null;
        //            }

        //        }
        //        PtlConsts.easyDb.CommitTrans();
        //        aschema.GetSchemaItemLst(); //获取方案项

        //    }
        //    catch (Exception ex)
        //    {
        //        errinfo = ex.Message;
        //        return null;
        //    }
        //    return aschema;
        //}
        #endregion


        #region 表型参数模板用方案
        /// <summary>
        /// 导出方案
        /// </summary>
        /// <param name="sfilename"></param>
        /// <param name="errinfo"></param>
        /// <returns></returns>
        //public int ExportSchPtl(string sfilename, ref string errinfo)
        //{
        //    int rs = 0;
        //    try
        //    {
        //        Application.DoEvents();
        //        #region 添加方案名信息
        //        PtlConsts.easyDb.Clear();
        //        PtlConsts.easyDb.TableName = ptltable;
        //        //PtlConsts.easyDb.SetWhereParameter(true, "ID", "=", ID, EasyDataType.String);
        //        PtlConsts.easyDb.SetWhereParameter(true, "SchType", "=", "1", EasyDataType.Number);
        //        DataTable dtSchema = PtlConsts.easyDb.Select();
        //        if (dtSchema.Rows.Count <= 0)
        //        {
        //            errinfo = clsLan.GetLan("未在数据库中找到方案") + "[" + sfilename + "]";
        //            return -1;
        //        }
        //        DataSet dsSchema = new DataSet();
        //        dtSchema.TableName = "T_PtlCfgSchema";
        //        dsSchema.Tables.Add(dtSchema.Copy());
        //        #endregion

        //        #region 添加方案项
        //        DataTable dtSchItem = ProSchemaItem.GetItemDataTableBySch("");
        //        dtSchItem.TableName = "T_PtlCfgSchemaItem";
        //        dsSchema.Tables.Add(dtSchItem.Copy());
        //        #endregion

        //        #region 添加方案项参数
        //        //DataTable dtSchItemPar = ProObAttr.GetParDataTablePar("");
        //        //dtSchItemPar.TableName = "T_PtlCfgSchemaItemPar";
        //        //dsSchema.Tables.Add(dtSchItemPar.Copy());
        //        #endregion


        //        #region 添加对象数据
        //        DataTable dtProObject = ProObject.GetObjectDateTable();
        //        dsSchema.Tables.Add(dtProObject.Copy());
        //        #endregion

        //        #region 添加属性数据
        //        DataTable dtProObAttr = ProObAttr.GetAttrDataTable();
        //        dsSchema.Tables.Add(dtProObAttr.Copy());
        //        #endregion



        //        #region 添加元素方案数据
        //        //DataTable dtProEleSch = ProEleSch.GetEleSchDateTable();
        //        //dsSchema.Tables.Add(dtProEleSch.Copy());
        //        #endregion

        //        #region 添加元素方案项数据
        //        //DataTable dtEleSchItem = ProEleSchItem.GetEleSchItemDateTable();
        //        //dsSchema.Tables.Add(dtEleSchItem.Copy());
        //        #endregion


        //        if (!RWOutFiles.DataSetToXMl(dsSchema, sfilename, ref errinfo))
        //            rs = -1;
        //    }
        //    catch (Exception ex)
        //    {
        //        rs = -1;
        //        errinfo = ex.Message;
        //    }

        //    return rs;
        //}



        /// <summary>
        /// 导入方案
        /// </summary>
        /// <param name="sfilename"></param>
        /// <param name="errinfo"></param>
        /// <returns></returns>
        //public static int ImportSchPtl(DataSet dsSchema, ref string errinfo)
        //{
        //    int rs = -1;
        //    try
        //    {
        //        //先删除原方案
        //        PtlConsts.easyDb.BeginTrans();
        //        rs = ProSchema.DeleteByType(TSchType.schPtl, ref errinfo);
        //        if (rs < 0)
        //        {
        //            PtlConsts.easyDb.RollbackTrans();
        //            return rs;
        //        }

        //        //导入方案
        //        DataTable dtSch = dsSchema.Tables[0];
        //        foreach (DataRow dr in dtSch.Rows)
        //        {
        //            Application.DoEvents();
        //            ProSchema aschema = GetModelByDataRow(dr);
        //            aschema.SchType = TSchType.schPtl;

        //            //清除原方案项
        //            rs = aschema.DeleteSchByID(ref errinfo);
        //            if (rs < 0)
        //            {
        //                PtlConsts.easyDb.RollbackTrans();
        //                return rs;
        //            }

        //            //保存导入方案
        //            rs = aschema.SaveSch(true, ref errinfo);
        //            if (rs < 0)
        //            {
        //                PtlConsts.easyDb.RollbackTrans();
        //                return rs;
        //            }
        //        }


        //        //方案项导入
        //        DataTable dtSchItem = dsSchema.Tables[1];
        //        foreach (DataRow dr1 in dtSchItem.Rows)
        //        {
        //            Application.DoEvents();
        //            ProSchemaItem schitem = ProSchemaItem.GetModelByDataRow(dr1, false);
        //            rs = schitem.SaveSchItem(true, ref errinfo);
        //            if (rs < 0)
        //            {
        //                PtlConsts.easyDb.RollbackTrans();
        //                return rs;
        //            }

        //        }

        //        //方案项参数导入
        //        DataTable dtSchItemPar = dsSchema.Tables[2];
        //        foreach (DataRow dr1 in dtSchItemPar.Rows)
        //        {
        //            Application.DoEvents();
        //            ProObAttr itempar = ProObAttr.GetModelByDataRow(dr1);
        //            //rs = itempar.SaveSchemaAttrPar(dr1["SchID"].ToString(), itempar.PID, true, ref errinfo);
        //            if (rs < 0)
        //            {
        //                PtlConsts.easyDb.RollbackTrans();
        //                return rs;
        //            }

        //        }

        //        PtlConsts.easyDb.CommitTrans();
        //    }
        //    catch (Exception ex)
        //    {
        //        errinfo = ex.Message;
        //        return -1;
        //    }
        //    return rs;
        //}
        #endregion
    }
}

